// 将 Date 转化为指定格式的 String
// 月(M)、日(d)、小时(h)、分(m)、秒(s)、季度(q) 可以用 1-2 个占位符，
// 年(y)可以用 1-4 个占位符，毫秒(S)只能用 1 个占位符(是 1-3 位的数字)
// 例子：
// formatDate(date, 'yyyy-MM-dd hh:mm:ss.S') ==> 2006-07-02 08:09:04.423
// formatDate(date, 'yyyy-M-d h:m:s.S')      ==> 2006-7-2 8:9:4.18
export const formatDate = (date, fmt = 'yyyy-MM-dd') => {
  let _date = new Date(date)
  let o = {
    'M+': _date.getMonth() + 1, // 月份
    'd+': _date.getDate(), // 日
    'h+': _date.getHours(), // 小时
    'm+': _date.getMinutes(), // 分
    's+': _date.getSeconds(), // 秒
    'q+': Math.floor((_date.getMonth() + 3) / 3), // 季度
    S: _date.getMilliseconds() // 毫秒
  }
  if (/(y+)/.test(fmt)) {
    fmt = fmt.replace(RegExp.$1, `${_date.getFullYear()}`.substr(4 - RegExp.$1.length))
  }
  for (let k in o) {
    if (new RegExp(`(${k})`).test(fmt)) {
      fmt = fmt.replace(
        RegExp.$1,
        RegExp.$1.length === 1 ? o[k] : `00${o[k]}`.substr(`${o[k]}`.length)
      )
    }
  }
  return fmt
}

// 防抖
// 多次触发事件后，事件处理函数只执行一次，并且是在触发操作结束时执行。
/**
 * @param fn 事件触发的操作
 * @param delay 间隔多少毫秒需要触发一次事件
 * @returns {Function}
 */
export const debounce = (fn, delay) => {
  let timer
  delay = delay || 200
  return function () {
    let th = this
    let args = arguments
    if (timer) {
      clearTimeout(timer)
    }
    timer = setTimeout(function () {
      timer = null
      fn.apply(th, args)
    }, delay)
  }
}

// 节流
// 触发函数事件后，短时间间隔内无法连续调用，只有上一次函数执行后，过了规定的时间间隔，才能进行下一次的函数调用。
/**
 * @param fn 事件触发的操作
 * @param interval 间隔多少毫秒需要触发一次事件
 * @returns {Function}
 */
export const throttle = (fn, interval) => {
  let last
  let timer
  interval = interval || 200
  return function () {
    let th = this
    let args = arguments
    let now = +new Date()
    if (last && now - last < interval) {
      clearTimeout(timer)
      timer = setTimeout(function () {
        last = now
        fn.apply(th, args)
      }, interval)
    } else {
      last = now
      fn.apply(th, args)
    }
  }
}

/**
 * 获取url后参数
 */
export const GetRequest = () => {
  // 获取url中'?'符后的字串
  let url = location.search
  // eslint-disable-next-line no-new-object
  let theRequest = new Object()
  if (url.indexOf('?') !== -1) {
    let str = url.substr(1)
    let strs = str.split('&')
    for (let i = 0; i < strs.length; i++) {
      theRequest[strs[i].split('=')[0]] = strs[i].split('=')[1]
    }
  }
  return theRequest
}

/**
 * 验证身份证号
 * @param el 号码输入input
 * @returns {boolean}
 */
export const checkCardNo = el => {
  let txtval = el.value
  let reg = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/
  return reg.test(txtval)
}

/**
 * 获取字符串字节长度
 * @param {String}
 * @returns {Boolean}
 */
export const checkLength = v => {
  let realLength = 0
  let len = v.length
  for (let i = 0; i < len; i++) {
    let charCode = v.charCodeAt(i)
    if (charCode >= 0 && charCode <= 128) realLength += 1
    else realLength += 2
  }
  return realLength
}

/**
 * 删除左右两端的空格
 * @param str
 * @returns {string | * | void}
 */
export const trim = str => {
  return str.replace(/(^\s*)|(\s*$)/g, '')
}

/**
 * 删除左边的空格
 * @param str
 * @returns {string | * | void}
 */
export const ltrim = str => {
  return str.replace(/(^\s*)/g, '')
}

/**
 * 删除右边的空格
 * @param str
 * @returns {string | * | void}
 */
export const rtrim = str => {
  return str.replace(/(\s*$)/g, '')
}

/**
 * 对象数组转二维数组
 * @param objArr
 */
export const obj2Arr = objArr => {
  objArr.length > 0 &&
    objArr.map(item => {
      return Object.values(item)
    })
}

/**
 * 判断当前网络环境
 */
export const isWifi = () => {
  try {
    let wifi = true
    let ua = window.navigator.userAgent
    let con = window.navigator.connection
    // 如果是微信
    if (/MicroMessenger/.test(ua)) {
      if (ua.indexOf('WIFI') >= 0) {
        return true
      } else {
        wifi = false
      }
      // 如果支持navigator.connection
    } else if (con) {
      let network = con.type
      if (network !== 'wifi' && network !== '2' && network !== 'unknown') {
        wifi = false
      }
    }
    return wifi
  } catch (e) {
    return false
  }
}

/**
 * 首字母大写
 * @param str
 * @returns {string}
 */
export const fistLetterUpper = str => {
  return str.charAt(0).toUpperCase() + str.slice(1)
}

/**
 * 过滤非法字符串
 */
export const illegalFilter = str => {
  let regEn = /[`~!@#$%^&*()_+<>?:"{},.\\/;'[\]]/im
  let regCn = /[·！#￥（——）：；“”‘、，|《。》？、【】[\]]/im

  if (regEn.test(str) || regCn.test(str)) return false
  return true
}

export const isNumber = val => {
  // 非负浮点数
  let regPos = /^\d+(\.\d+)?$/
  // 负浮点数
  let regNeg = /^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$/
  if (regPos.test(val) || regNeg.test(val)) {
    return true
  } else {
    return false
  }
}
